### deleteKey

Returns a new object with the provided key deleted.


```ts
function deleteKey<T, K extends keyof T>(dict: T, key: K): Omit<T, K>
function deleteKey<T, K extends keyof T>(key: K): (dict: T) => Omit<T, K>
```

```ts
D.deleteKey({ name: 'Joe', location: 'Warsaw' }, 'location') // → { name: 'Joe' }
pipe({ name: 'Joe', location: 'Warsaw' }, D.deleteKey('location')) // → { name: 'Joe' }
```

### deleteKeys

Returns a new object with the provided keys deleted.


```ts
function deleteKeys<T, K extends keyof T>(dict: T, keys: ReadonlyArray<K>): Omit<T, K>
function deleteKeys<T, K extends keyof T>(keys: ReadonlyArray<K>): (dict: T) => Omit<T, K>
```

```ts
D.deleteKeys({ name: 'Joe', location: 'Warsaw' }, []) // → {
  name: 'Joe',
  location: 'Warsaw',
}
D.deleteKeys({ name: 'Joe', location: 'Warsaw' }, ['name']) // → { location: 'Warsaw' }
D.deleteKeys({ name: 'Joe', location: 'Warsaw' }, ['name', 'location']) // → {}
pipe({ name: 'Joe', location: 'Warsaw' }, D.deleteKeys([])) // → {
  name: 'Joe',
  location: 'Warsaw',
}
pipe({ name: 'Joe', location: 'Warsaw' }, D.deleteKeys(['name'])) // → { location: 'Warsaw' }
pipe(
  { name: 'Joe', location: 'Warsaw' },
  D.deleteKeys(['name', 'location']),
) // → {}
```

### filter

Removes each property that doesn't satisfy the given predicate function.


```ts
function filter<T extends Record<string, any>>(dict: T, predicateFn: (value: T[keyof T]) => boolean): Partial<T>
function filter<T extends Record<string, any>>(predicateFn: (value: T[keyof T]) => boolean): (dict: T) => Partial<T>
```

```ts
D.filter({ name: 'Joe', age: 20 }, value => value === 20) // → { age: 20 }
pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.filter(value => value === 'Joe'),
) // → { name: 'Joe' }
```

### filterWithKey

Removes each property that doesn't satisfy the given predicate function (which takes two arguments: a property value and key).


```ts
function filterWithKey<T extends Record<string, any>>(dict: T, predicateFn: (key: keyof T, value: T[keyof T]) => boolean): Partial<T>
function filterWithKey<T extends Record<string, any>>(predicateFn: (key: keyof T, value: T[keyof T]) => boolean): (dict: T) => Partial<T>
```

```ts
D.filterWithKey(
  { name: 'Joe', age: 20 },
  (key, value) => value === 30 && key === 'age',
) // → {}

pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.filterWithKey((key, _) => key === 'name'),
) // → { name: 'Joe' }
```

### fromPairs

Creates a new object from an array of tuples (`[key, value]`).


```ts
function fromPairs<T, K extends string | number>(xs: Array<readonly [K, T]>): Record<string, T>
```

```ts
D.fromPairs([
  ['name', 'Joe'],
  ['location', 'Warsaw'],
] as const) // → { name: 'Joe', location: 'Warsaw' }

pipe(
  [
    ['name', 'Joe'],
    ['location', 'Warsaw'],
  ] as const,
  D.fromPairs,
) // → { name: 'Joe', location: 'Warsaw' }
```

### get

Returns `Some(value)` if the given key exists, otherwise returns `None`.


```ts
function get<T, K extends keyof T>(dict: T, key: K): Option<ExtractValue<T[K]>>
function get<T, K extends keyof T>(key: K): (dict: T) => Option<ExtractValue<T[K]>>
```

```ts
D.get({ name: 'Joe', location: 'Warsaw' }, 'location') // → Some('Warsaw')
pipe({ name: 'Joe', location: 'Warsaw' }, D.get('location')) // → Some('Warsaw')
pipe([{ name: 'Joe' }, { location: 'Warsaw' }], A.map(D.get('name'))) // → [Some('Joe'), None]
```

### getUnsafe

Returns the value if the given key exists, otherwise returns `undefined`.


```ts
function getUnsafe<T, K extends keyof T>(dict: T, key: K): T[K]
function getUnsafe<T, K extends keyof T>(key: K): (dict: T) => T[K]
```

```ts
D.getUnsafe({ name: 'Joe', location: 'Warsaw' }, 'location') // → 'Warsaw'
pipe({ name: 'Joe', location: 'Warsaw' }, D.getUnsafe('location')) // → 'Warsaw'
pipe(
  [{ name: 'Joe' }, { location: 'Warsaw' }],
  A.map(D.getUnsafe('name')),
) // → ['Joe', undefined]
```

### isEmpty

Determines whether the given object is empty.


```ts
function isEmpty<T extends Record<string, any>>(dict: T): boolean
```

```ts
D.isEmpty({ name: 'Joe', age: 20 }) // → false
D.isEmpty({}) // → true
pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.isEmpty,
) // → false

pipe({}, D.isEmpty) // → true
```

### isNotEmpty

Determines whether the given object is not empty.


```ts
function isNotEmpty<T extends Record<string, any>>(dict: T): boolean
```

```ts
D.isNotEmpty({ name: 'Joe', age: 20 }) // → true
D.isNotEmpty({}) // → false
pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.isNotEmpty,
) // → true

pipe({}, D.isNotEmpty) // → false
```

### keys

Returns a new array that contains all keys of the provided object.


```ts
function keys<T extends Record<string, unknown>>(dict: T): Array<keyof T>
```

```ts
D.keys({
  name: 'Joe',
  age: 20,
}) // → ['name', 'age']

pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.keys,
) // → ['name', 'age']
```

### makeEmpty

Creates an empty object. Alternative for `const obj = {} as SomeObjectType`.


```ts
function makeEmpty<T>(): T
```

### map

Transforms each value in the object to a new value using the provided function.


```ts
function map<T extends Record<string, any>, R>(dict: T, mapFn: (value: T[keyof T]) => R): Record<keyof T, R>
function map<T extends Record<string, any>, R>(mapFn: (value: T[keyof T]) => R): (dict: T) => Record<keyof T, R>
```

```ts
D.map(
  {
    name: 'Joe',
    location: 'Warsaw',
  },
  value => value.length,
) // → { name: 3, location: 6 }

pipe(
  {
    name: 'Joe',
    location: 'Warsaw',
  },
  D.map(value => value.length),
) // → { name: 3, location: 6 }
```

### mapWithKey

Transforms each value in the object to a new value using the provided function (which takes two arguments: a property value and key).


```ts
function mapWithKey<T extends Record<string, any>, R>(dict: T, mapFn: (key: keyof T, value: T[keyof T]) => R): Record<keyof T, R>
function mapWithKey<T extends Record<string, any>, R>(mapFn: (key: keyof T, value: T[keyof T]) => R): (dict: T) => Record<keyof T, R>
```

```ts
D.mapWithKey(
  {
    name: 'Joe',
    location: 'Warsaw',
  },
  (key, value) => `${key}-${value.toLowerCase()}`,
) // → { name: 'name-joe', location: 'location-warsaw' }

pipe(
  {
    name: 'Joe',
    location: 'Warsaw',
  },
  D.mapWithKey((key, value) => `${key}-${value.toLowerCase()}`),
) // → { name: 'name-joe', location: 'location-warsaw' }
```

### merge

Merges two provided objects.


```ts
function merge<A, B>(fst: A, snd: B): A & B
function merge<A, B>(snd: B): (fst: A) => A & B
```

```ts
D.merge({ x: 1, y: 2 }, { y: 3, z: 4 }) // → { x: 1, y: 3, z: 4 }
pipe({ x: 1, y: 2 }, D.merge({ y: 3, z: 4 })) // → { x: 1, y: 3, z: 4 }
```

### prop

@deprecated Use either `D.get` or `D.getUnsafe` instead.


```ts
function prop<T, K extends keyof T>(dict: T, key: K): T[K]
function prop<T, K extends keyof T>(key: K): (dict: T) => T[K]
```

### reject

Removes each property that satisfies the given predicate function.


```ts
function reject<T extends Record<string, any>>(dict: T, predicateFn: (value: T[keyof T]) => boolean): Partial<T>
function reject<T extends Record<string, any>>(predicateFn: (value: T[keyof T]) => boolean): (dict: T) => Partial<T>
```

```ts
D.reject({ name: 'Joe', age: 20 }, value => value === 20) // → { name: 'Joe' }
pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.reject(value => value === 'Joe'),
) // → { age: 20 }
```

### rejectWithKey

Removes each property that satisfies the given predicate function (which takes two arguments: a property value and key).


```ts
function rejectWithKey<T extends Record<string, any>>(dict: T, predicateFn: (key: keyof T, value: T[keyof T]) => boolean): Partial<T>
function rejectWithKey<T extends Record<string, any>>(predicateFn: (key: keyof T, value: T[keyof T]) => boolean): (dict: T) => Partial<T>
```

```ts
D.rejectWithKey(
  { name: 'Joe', age: 20 },
  (key, value) => value === 20 && key === 'age',
) // → { name: 'Joe' }

pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.rejectWithKey((key, _) => key === 'name'),
) // → { age: 20 }
```

### selectKeys

Returns a new object with the provided keys selected.


```ts
function selectKeys<T, K extends keyof T>(dict: T, keys: ReadonlyArray<K>): Pick<T, K>
function selectKeys<T, K extends keyof T>(keys: ReadonlyArray<K>): (dict: T) => Pick<T, K>
```

```ts
D.selectKeys({ name: 'Joe', location: 'Warsaw', age: 42 }, [
  'name',
  'age',
]) // → { name: 'Joe', age: 42 }

// ⬇️ const obj: Record<string, string> = { name: 'Joe', location: 'Warsaw' }
D.selectKeys(obj, ['name', 'age']) // → { name: 'Joe' }

pipe(
  { name: 'Joe', location: 'Warsaw', age: 42 },
  D.selectKeys(['name', 'age']),
) // → { name: 'Joe', age: 42 }

// ⬇️ const obj: Record<string, string> = { name: 'Joe', location: 'Warsaw' }
pipe(obj, D.selectKeys(['name', 'age'])) // → { name: 'Joe' }
```

### set

Adds a property. Equivalent to merging with `{key: value}`


```ts
function set<T, K extends string | number, V>(dict: T, key: K, value: V): T & Record<K, V>
function set<T, K extends string | number, V>(key: K, value: V): (dict: T) => T & Record<K, V>
```

```ts
D.set({ name: 'Joe', location: 'Warsaw' }, 'location', 'Gdańsk') // → { name: 'Joe', location: 'Gdańsk' }
D.set({ 0: false, 1: true }, 1, 'abc') // → { 0: false, 1: 'abc' }
pipe({ name: 'Joe', location: 'Warsaw' }, D.set('location', 'Gdańsk')) // → { name: 'Joe', location: 'Gdańsk' }
pipe({ 0: false, 1: true }, D.set(1, 'abc')) // → { 0: false, 1: 'abc' }
```

### toPairs

Converts an object into an array of `[key, value]` tuples.


```ts
function toPairs<T, K extends string | number>(dict: Record<K, T>): Array<readonly [string, T]>
```

```ts
D.toPairs({
  name: 'Joe',
  age: 20,
}) // → [['name', 'Joe'], ['age', 20]]

pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.toPairs,
) // → [['name', 'Joe'], ['age', 20]]
```

### update

Updates a property by applying the provided function to the corresponding optional value.


```ts
function update<T, K extends keyof T, R>(dict: T, key: K, fn: (value: Option<T[K]>) => R): T & Record<K, R>
function update<T, K extends keyof T, R>(key: K, fn: (value: Option<T[K]>) => R): (dict: T) => T & Record<K, R>
```

```ts
D.update({ name: 'Joe', location: 'Warsaw' }, 'name', option =>
  O.mapWithDefault(option, 'unknown', S.toUpperCase),
) // → { name: 'JOE', location: 'Warsaw' }

// ⬇️ const obj: Record<string, string> = { name: 'Joe', location: 'Warsaw' }
D.update(obj, 'key', option =>
  O.mapWithDefault(option, 'unknown', S.toUpperCase),
) // → { name: 'Joe', key: 'unknown', location: 'Warsaw' }

pipe(
  { name: 'Joe', location: 'Warsaw' },
  D.update('name', option =>
    O.mapWithDefault(option, 'unknown', S.toUpperCase),
  ),
) // → { name: 'JOE', location: 'Warsaw' }

// ⬇️ const obj: Record<string, string> = { name: 'Joe', location: 'Warsaw' }
pipe(
  obj,
  D.update('key', option =>
    O.mapWithDefault(option, 'unknown', S.toUpperCase),
  ),
) // → { name: 'Joe', key: 'unknown', location: 'Warsaw' }
```

### updateUnsafe

Updates a property by applying the provided function to the corresponding value.


```ts
function updateUnsafe<T, K extends keyof T, R>(dict: T, key: K, fn: (value: T[K]) => R): T & Record<K, R>
function updateUnsafe<T, K extends keyof T, R>(key: K, fn: (value: T[K]) => R): (dict: T) => T & Record<K, R>
```

```ts
D.updateUnsafe(
  { name: 'Joe', location: 'Warsaw' },
  'name',
  S.toUpperCase,
) // → { name: 'JOE', location: 'Warsaw' }

D.updateUnsafe({ 0: false, 1: true }, 1, B.inverse) // → { 0: false, 1: false }
pipe(
  { name: 'Joe', location: 'Warsaw' },
  D.updateUnsafe('name', S.toUpperCase),
) // → { name: 'JOE', location: 'Warsaw' }

pipe({ 0: false, 1: true }, D.updateUnsafe(1, B.inverse)) // → { 0: false, 1: false }
```

### values

Returns a new array that contains all values of the provided object.


```ts
function values<T extends string | number, R>(dict: Record<T, R>): Array<R>
```

```ts
D.values({
  name: 'Joe',
  age: 20,
}) // → ['Joe', 20]

pipe(
  {
    name: 'Joe',
    age: 20,
  },
  D.values,
) // → ['Joe', 20]
```